Microsoft CodeView and Utilities
================================
CHAPTER 10 ___ MODIFYING CODE OR DATA

The CodeView debugger provides the following commands for modifying code or
data in memory:

Command		Action
--------------------------
Assemble (A)	Modifies code

Enter (E)	Modifies memory, usually data

Register (R)	Modifies registers and flags

Fill Memory (F)	Fills a block of memory

Move Memory (M)	Copies one block of memory to another

Port Output (O)	Outputs a byte to a hardware port

These commands change code temporarily.  You can use the alterations for
testing in the CodeView debugger, but you cannot save them or permanently
change the program.  To make permanent changes, you must modify the source
code and recompile.

10.1  Assemble Command

The Assemble command assembles 8086-family (8086, 8087, 8088, 80186, 80287,
and 80286 unprotected) instruction mnemonics and places the resulting
instruction code into memory at a specified address.  The only 8086-family
mnemonics that cannot be assembled are 80286 protected-mode mnemonics.  In
addition, the debugger will also assemble 80286 instructions that utilize the
expanded 386 registers.
----
Note
----
The effects of the Assemble command are temporary.  Any instructions that
you assemble are list as soon as you exit the program.

The instructions you assemble are also lost when you restart the program
with the Start or Restart command, because the original code is reloaded on
top of memory you may have altered.

To test the results of an Assemble command, you may need to manipulate the
IP register (and possibly the CS register) to the starting address of the
instructions you have assembled.  If you do this, you must use the Current
Line command (.) to reset the debugger's internal variables so that it will
trace properly.
====

<*> Mouse

The Assemble command cannot be executed with the mouse.

<*> Keyboard

The Assemble command cannot be executed with a keyboard command.

<*> Dialog

To assemble code using a dialog command, enter a command line with the
following syntax:

A [address]

If address is specified, the assembly starts at that address; otherwise the
current assembly address is assumed.
The assembly address is normally the current address (the address pointed to
by the CS and IP registers).  However, when you use the Assemble command , the
assembly address is set to the address immediately following the last
assembled instruction.  When you enter any command that executes code (Trace,
Program Step, Go, or Execute), the assembly address is reset to the current
address.

When you type the Assemble command, the assembly address is displayed.  The
CodeView debugger then waits for you to enter a new instruction in the
standard 8086-family instruction-mnemonic form.  You can enter instructions in
uppercase, lowercase, or both.

To assemble a new instruction, type the desired mnemonic and press the ENTER
key.  The CodeView debugger assembles the instruction into memory and displays
the next available address.  Continue entering new instructions until you have
assembled all the instructions you want.  To conclude assembly and return to
the CodeView prompt, press the ENTER key only.

If an instruction you enter contains a syntax error, the debugger displays the
message  ^ Suntax error, redisplays the current assembly address, and waits
for you to enter a correct instruction.  The caret symbol in the message will
point to the first character the CodeView debugger could not interpret.

The following eight principles govern entry of instruction mnemonics:

1. The far-return mnemonic is RETF.

2. String mnemonics must explicitly state the string size.  For example, MOVSW
must be used to move word strings, and MOVSB must be used to move byte
strings.

3. The CodeView debugger automatically assembles short, near, or far jumps and
calls, depending on byte displacement to the destination address.  These
may be overridden with the NEAR or FAR prefix, as shown in the following
examples:

JMP	0x502
JMP	NEAR 0x505
JMP	FAR  0x50A

The NEAR prefix can be abbreviated to NE, but the FAR prefix cannot be
abbreviated.  The examples above use the C notation for hexadecimal
numbers.  If the FORTRAN option were selected, then you would enter the
operands as #502, #505, and #50A; if the BASIC option were selected, you
would enter them as &H502, &H505, &H50A.

4. The CodeView debugger cannot determine whether some operands refer to a
word memory location or a byte memory location.  In these cases, the data
type must be explicitly stated with the prefix WORD PTR or BYTE PTR.
Acceptable abbreviations are WO and BY.  Examples are shown below:

MOV	WORD PTR [BP],1
MOV	BYTE PTR [SI-1],symbol
MOV	WO PTR [BP],1
MOV	BY PTR [SI-1],symbol

5. The CodeView debugger cannot determine whether an operand refers to a
memory locations or to an immediate operand.  The debugger uses the
convention that operands enclosed in square brackets refer to memory.  Two
examples are shown below:

MOV	AX,#21
MOV	AX,[#21]

The first statement moves 21 hexadecimal into AX.  The second statement
moves the data at offset 21 hexadecimal into AX.  Both statements use the
FORTRAN notation for the hexadecimal number 21.  If the C option were
selected, then this number would be represented as 0x21, and if the BASIC
option were selected, then the number would be represented as &H21.

6. The CodeView debugger supports all forms of indirect register instructions,
as shown in the following examples:

ADD	BX,[BP+2].[SI-1]
POP	[BP+DI]
PUSH	[SI]

7. All instruction-name synonyms are supported.  If you assemble instructions
and then examine them with the Unassemble command (U), the CodeView
debugger may show synonymous instructions, rather than the ones you
assembled, as shown in the following examples:

LOOPZ	&H100
LOOPE	&H100
JA	&H200
JNBE	&H200

The examples above use the BASIC hexadecimal notation.  Instead of using
the &H prefix, you would use 0x with the C option selected, and # with the
FORTRAN option selected.

8. Do not assemble and execute 8087 or 80287 instructions if your system is
not equipped with one of these math coprocessor chips.  If you try to
execute the WAIT instruction without the appropriate chip, for example,
your system will crash.

<*> Example

>U #40 L 1
39B0:0040 89C3		MOV	BX,AX
>A #40
39B0:0040		MOV	CS,AX
39B0:0042
>U #40 L 1
39B0:0040 89C1		MOV	CX,AX
>

The example above (in FORTRAN notation) modifies the instruction at address 40
hexadecimal so that it moves data into the CX register instead of the jBX
register (40 hexadecimal is notated as 0x40 in C, and as &H40 in BASIC).  The
Unassemble command (U) is used to show the instruction before and after the
assembly.

You can modify a portion of code for testing, as in the example, but you
cannot save the modified program.  You must modify your source code and
recompile.

10.2  Enter Commands

The CodeView debugger has several commands for entering data to memory.  You
can use these commands to modify either code or data, though code can usually
be modified more easily with the Assemble command (A).  The Enter commands are
listed below:

Command		Command Name
----------------------------
E		Enter (size is the default type)
EB		Enter Bytes
EA		Enter ASCII
EI		Enter Integers
EU		Enter Unsigned Integers
EW		Enter Words
ED		Enter Double Words
ES		Enter Short Reals
EL		Enter Long Reals
ET		Enter 10-Byte Reals

<*> Mouse

The Enter commands cannot be executed with the mouse.

<*> Keyboard

The Enter commands cannot be executed with keyboard commands.

<*> Dialog

To enter data (or code) to memory with a dialog command, enter a command line
with the following syntax:

E[type] address [list]
The  type  is a one-letter specifier that indicates the type of the data to be
entered.  The   address  indicates where the data will be entered.  If no
segment is given in the address, the data segment (DS) is assumed.  The  list
can consist of one or more expressions that evaluate to data of the size
specified by  type  (the expressions in the list are separated by spaces).
This data will be entered to memory at  address.  If one of the values in the
list is invalid, an error message will be displayed.  The values preceding the
error are entered; values at and following the error are not entered.

The expressions in the list are evaluated in the current radix, regardless of
the size and type of data being entered.  For example, if the radix is 10 and
you give the value 10 in a list with the Enter Words command, the decimal
value 10 will be entered even though word values are normally entered in
hexadecimal.  This means that the Enter Words, Enter Integers, and Ente
Unsigned Integers commands are identical when used with the list method, since
two-byte data are being entered for each command.

If  list  is not given, the CodeView debugger will prompt for values to be
entered to memory.  Values entered in response to prompts are accepted in
hexadecimal for the Enter Bytes, Enter ASCII, Enter Words, and Enter Double
Words commands.  The Enter Integers command accepts signed decimal integers,
while the Enter Unsigned Integers command accepts unsigned decimal integers.
The Enter Short Reals, Enter Long Reals, and Enter 10-Byte Reals commands
accept decimal floating-point values.

With the prompting method of data entry, the CodeView debugger prompts for a
new value at  address  by displaying the address and its current value.  As
explained below, you can then replace the value, skip to the next value, or
exit the command.

*  To replace the value, type the new value after the current value.

*  To skip to the next value, press the SPACEBAR.  Once you have skipped
to the next value, you can change its value or skip to the following
value.  If you pass the end of the display, the CodeView debugger
displays a new address to start a new display line.

*  To return to the preceding value, type a backslash (\).  When you
return to the preceding value, the debugger starts a new display line
with the address and value.

*  To stop entering values and return to the CodeView prompt, press the
ENTER key.  You can exit the command at any time.

Sections 10.2.1--10.2.10 discuss the Enter commands in order of the size of
data they accept.

<*> Examples

>EW PLACE 16 32

The example above shows how to enter two word-sized values at the address
PLACE.

>EW PLACE

3DA5:0B20  00F3._

The example above illustrates the prompting method of entering data.  When you
supply the address where you want to enter data but supply no data to be
entered there, the CodeView debugger displays the current value of the address
and waits for you to enter a new value.  The underscore in this example and
the examples below represents the CodeView cursor.  You change the value F3 to
the new value 16 (10 hexadecimal) by typing 10 (without pressing the ENTER key
yet).  The value must be typed in hexadecimal for the Enter Words command, as
shown below:

>EW PLACE

3DA5:0B20  00F3.10_

You can then skip to the next value by pressing the SPACEBAR.  The CodeView
debugger responds by displaying the next value, as shown below:

>EW PLACE

3DA5:0B20  00F3.10  4F20._

You can then type another hexadecimal value, such as 30:

>EW PLACE

3DA5:0B20  00F3.10  4F20.30_

To move to the next value, press the SPACEBAR.

>EW PLACE

3DA5:0B20  00F3.10  4F20.30  3DC1._

Assume you realize that the last value entered, 30, is incorrect.  You really
wanted to enter 20.  You could return to the previous value by typing a
backslash.  The CodeView debugger starts a new line, starting with the
previous value.  Note that the backslash is not echoed on the screen:

>EW PLACE

3DA5:0B20  00F3.10  4F20.30  3DC1.
3DA5:0B22  0030._

Type the correct value, 20:

>EW PLACE

3DA5:0B20  00F3.10  4F20.30  3DC1.
3DA5:0B22  0030.20_

If this is the last value you want to enter, press the ENTER key to stop.
The CodeView prompt reappears, as shown below:

>EW PLACE

3DA5:0B20  00F3.10  4F20.30
3DA5:0B22  0030.20
>_

10.2.1  Enter Command

<*>  Syntax

E address [list]

The Enter command enters one or more values into memory at the specified
address.  The data are entered in the format of the default type, which is the
last type specified with a Dump, Enter, Watch Memory, or Tracepoint Memory
command.  If none of these commands has been entered during the session, the
default type is bytes.

Use this command with caution when entering values in the list format; values
will be truncated if you enter a word-sized value when the default type is
actually bytes.  If you are not sure of the currentdefault type,  specify the
size in the command.
---------
Important
---------
The Execute command and the Enter command have the same command letter (E).
The difference is that the Execute command never takes an argument; the
Enter command always requires at least one argument.
=========

10.2.2  Enter Bytes Command

<*> Syntax

EB address [list]

The Enter Bytes command enters one or more byte values into memory at address.
The optional  list  can be entered as a list of expressions separated by
spaces.  The expressions are evaluated and entered in the current radix.  If
list is not given, the CodeView debugger prompts for new values, which must be
entered in hexadecimal.

The Enter Bytes command can also be used to enter strings, as described in
Section 10.2.3, "Enter ASCII Command."

<*> Examples

>EB 256 10 20 30
>
If the current radix is 10, the above example replaces the three bytes at
DS:256, DS:257 and DS:258 with the decimal values 10, 20, and 30.  (These
three bytes correspond to the hexadecimal addresses DS:0100, DS:0101, and
DS:0102.)
>EB 256

3DA5:0100  130F.A
>

The example above replaces the byte at DS:256 (DS:0100 hexadecimal)
with 10 (0A hexadecimal).

10.2.3  Enter ASCII Command

<*> Syntax

EA address [list]

The Enter ASCII command works in the same way as the Enter Bytes command (EB)
described in Section 10.2.2.  The  list  version of this command can be used
to enter a string expression.

<*> Example

>EA message "File cannot be found"
>

In the example above, the string  File cannot be found  is entered starting at
the symbolic address  message. (Note that the double quotation marks are
CodeView string delimiters.)

You can also use the Enter Bytes command to enter a string expression, or you
can enter nonstring values using the Enter ASCII command.

10.2.4  Enter Integers Command

<*> Syntax

EI address [list]

The Enter Integers command enters one or more word values into memory at
address using the signed-integers format.  With the CodeView debugger, a
signed integer can be any decimal integer between -32,768 and 32,767.

The optional  list  can be entered as a list of expressions separated by
spaces.  The expressions are entered and evaluated in the current radix.  If
list  is not given, the CodeView debugger prompts for new values, which must
be entered in decimal.

<*> Examples

>EI 256 -10 10 -20
>

If the current radix is 10, the example above replaces the three integers at
DS:256, DS:258, and DS:260 with the decimal values -10, 10, and -20.  (The
three addresses correspond to the three hexadecimal addresses DS:0100,
DS:0102, and DS:0104.)
>EI 256

3DA5:0100  130F.-10
>

The example above replaces the integer at DS:256 (hexadecimal address DS:0100)
with -10.

10.2.5  Enter Unsigned Integers Command

<*> Syntax

EU address [list]

The Enter Unsigned Integers command enters one or more word values into memory
at  address  using the unsigned-integers format.  With the CodeView debugger,
an unsigned integer can be any decimal integer between 0 and 65,535.  The
optional  list  can be entered as a list of expressions separated by spaces.
The expressions are entered and evaluated in the current radix.  If  list is
not given, the CodeView debugger prompts for new values, which must be entered
in decimal.

<*> Examples

>EU 256 10 20 30
>

If the current radix is 10, the example above replaces the three unsigned
integers at DS:256, DS:258, and DS:260 with the decimal values 10, 20, and 30.
(These addresses correspond to the hexadecimal addresses DS:0100, DS:0102, and
DS:0104.)

>EU 256

3DA5:0100  130F.10
>

The example above replaces the integer at DS:256 (DS:0100 hexadecimal) with
10.

10.2.6  Enter Words Command

<*> Syntax

EW address [list]

The Enter Words command enters one or more word values into memory at  address.

The optional  list  list  The expressions are entered and evaluated in the
current radix.  If  list  is not given, the CodeView debugger prompts for new
values, which must be entered in hexadecimal.

<*> Examples

>EW 256 10 20 30
>

If the current radix is 10, the example above replaces the three words at
DS:256, DS:258, and DS:260 with the decimal values 10, 20, and 30. (These
addresses correspond to the hexadecimal addresses DS:0100, DS:0102, and
DS:0104.)

>EW 256

3DA5:0100  130F.A
>

The example above replaces the integer at DS:256 (DS:0100 hexadecimal) with 10
(0A hexadecimal).

10.2.7  Enter Double Words Command

<*> Syntax

ED address [list]

The Enter Double Words command enters one or more double-word values into
memory at address.  Double words are displayed and entered in the
argument:offset address format; that is, two words separated by a colon (:).
If the colon is omitted and only one word entered, only the offset portion of
the address will be changed.

The optional  list  can be entered as a list of expressions separated by
spaces.  The expressions are entered and evaluated in the current radix.  If
list  is not given, the CodeView debugger prompts for new values, which must
be entered in hexadecimal.

<*>  Examples

>ED 256 8700:12008
>

If the current radix is 10, the example above replaces the double words at
DS:256 (DS:0100 hexadecimal) with the decimal address 8700:12008 (hexadecimal
address 21FC:2EE8).

>ED 256

3DA5:0100  21FC:2EE9
>

The example above replaces the offset portion of the double word at DS:256
(DS:0100 hexadecimal) with 2EE9 hexadecimal.  Since the segment portion of the
address is not provided, the existing segment (21FC hexadecimal) is unchanged.

10.2.8  Enter Short Reals Command

<*> Syntax

ES address [list]

The Enter Short Reals command enters one or more short-real values into memory
at  address.

The optional  list  can be entered as a list of real numbers separated by
spaces.  The numbers must be entered in decimal, regardless of the current
radix.  If  list  is not given, the CodeView debugger prompts for new values,
either in floating-point format or in scientific notation format.

<*> Examples

>ES 256 23.479 1/4 -1.65E+4 235
>

The example above replaces the four numbers at DS:256, DS:260, DS:264 and
DS:268 with the real numbers 23.479, 0.25, -1650.0, and 235.0. (These 
addresses correspond to the hexadecimal addresses DS:0100, DS:0104, DS:0108,
and DS:0112.)

>ES PI
3DA5:0064  42 79 74 65   7.215589E+022  3.141593
>

The example above replaces the number at the symbolic address PI with
3.141593.

10.2.9  Enter Long Reals Command

<*> Syntax

EL address [list]

The Enter Long Reals command enters one or more long-real values into memory
at  address.

The optional  list  can be entered as a list of real numbers separated by
spaces.  The numbers must be entered in decimal, regardless of the current
radix.  If  list  is not given, the CodeView debugger prompts for new values,
which must be entered in decimal.  Long-real numbers can be entered either in
floating-point format or in scientific notation format.

<*> Examples

>EL 256 23.479 1/4 -1.65E+4 235
>
The example above replaces the four numbers at DS:256, DS:266, DS:276, and
DS:286 with the real numbers 23.479, 0.25, -1650.0, and 235.0. (These
addresses correspond to the hexadecimal addresses DS:0100, DS:010A, DS:0114,
and DS:011E.)
>ET PI
3DA5:0064  42 79 74 65 DC 0F 49 40 7F BD   -3.292601E-193  3.141593
>

The example above replaces the number at the symbolic address PI with
3.141593.

10.3  Fill Memory Command

The Fill Memory command provides an efficient way of filling up a large or
small block of memory, with any value you specify.  It is primarily of
interrest to assembly programmers because the command enters values directly
into memory.  However, you may find it useful for initializing large data
areas such as an array or structure.

You can enter arguments to the Fill Memory command using any radix.

<*> Mouse

The Fill Memory command cannot be executed with a mouse.

<*> Keyboard

The Fill Memory command cannot be executed with a keyboard command.

<*> Dialog

To fill an area of memory with values you specify, enter the Fill Memory
command as follows:

F range list

The Fill Memory command fills the addresses in the specified range with the
byte values specified in  list.  The values in the list are repeated until the
whole range is filled. (Thus, if you specify only one value, the entire range
is filled with that same value.) If the  list has more values than the number
of bytes in the range, then the command ignores any extra values.

<*>  Examples

>F 100 L 100 0    ;* hexadecimal radix assumed
>

The first example fills 255 (100 hexadecimal) bytes of memory starting at
DS:0100 with the value 0.  This command might possibly be used to reinitialize
the program's data without having to restart the program.

>F table L 64 42 79 74  ;* hexadecimal radix assumed
>

The second example fills the 100 (64 hexadecimal) bytes starting at  table
with the following hexadecimal byte values: 42,79, 74.  These three values are
repeated until all 100 bytes are filled.

10.4  Move Memory Command

The Move Memory command enables you to copy all the values in one block of
memory directly to another block of memory of the same size.  This command is
of most interest to assembly programmers, but can be used by anyone who wants
to do large data transfers efficiently.  For example, you can use this command
to copy all the values in one array to the elements of another.

<*> Mouse

The Move Memory command cannot be executed with the mouse.

<*> Keyboard

The Move Memory command cannot be executed with a keyboard command.

<*> Dialog

To copy the values in one block of memory to another, enter the Move Memory
command with the following syntaxf:

M range address

The values in the block of memory specified by range are copied to a block of
the same size beginning at  address.  All data in range are guaranteed to be
copied completely over to the destination block, even if the two blocks
overlap.  However, if they do overlap, some of the original data in  range
will be altered.

To prevent loss of data, the Move Memory command copies data starting at the
source block's lowest address whenever the source is at a higher address than
the destination.  If the source is at a lower address, then the Move Memory
command copies data beginning at the source block's highest address.

<*> Example

>M arr1(1) L arsize arr2(1)     ;* FORTRAN example
>

In the example above, the block of memory beginning with the first element of
arr1, and arsize bytes long, is copied directly to a block of the same size
beginning at the address of the first element of arr2.  In C, this command
would be entered as M arr1[0] L arsize arr2[0].

10.5  Port Output Command

The Port Output command sends specific byte values to hardware ports.  It is
primarily of use to assembly programmers writing code that interacts directly
with hardware.

<*> Mouse

The Port Output command cannot be executed with a mouse.

<*> Keyboard

The Port Output command cannot be executed with a keyboard command.

<*> Dialog

To output to a hardware port, enter the Port Output command with the following
syntax:

O port byte

The specified byte is sent to the specified port, in which  port  is a 16-bit
port address.

<*> Example

>0 2F8 4F       ;* hexadecimal system radix assumed
>

The byte value 4F hexadecimal is sent to output port 2F8.

The example above assumes that the system radix is hexadecimal; however (as
with all other CodeView commands), you can enter the Port Output command using
any radix you prefer.  Both the port and byte arguments will assume system
radix, unless you specify a radix override.

The Port Output command is often used in conjunction with the Port Input
command, which is discussed in Section 6.6.

10.6  Register Command

The Register command has two functions: it displays the contents of the
central processing unit registers, and it can also change the values of those
registers.  The modification features of the command are explained in this
section.  The display features of the Register command are explained in
Section 6.7.

<*> Mouse

The only register that can be changed with the mouse is the flags register.
The register's individual bits (called flags) can be set or cleared.  To
change a flag, first make sure the register window is open.  The window can be
opened by selecting Registers from the Options menu or by pressing the F2 key.

The flag values are shown as mnemonics in the bottom of the window.  Point to
the flag you want to change and click either button.  The mnemonic word
representing the flag value will change.  The mnemonics for each flag are
shown in the third and fifth columns of Table 10.1.  The color or highlighting
of the flag will also be reversed when you change a flag.  Set flags are shown
in red on color monitors and in high-intensity text on two-color monitors.
Cleared flags are shown in light blue on color monitors or normal text on two-
color monitors.

<*> Keyboard

The registers cannot be changed with keyboard commands.

<*> Dialog

To change the value of a register with a dialog command, enter a command line
with the following syntax:

R [registername[[=]expression]]

To modify the value in a register, type the command letter R followed by
registername.  The CodeView debugger displays the current value of the
register and prompts for a new value.  Press the ENTER key if you only want to
examine the value.  If you want to change it, type an expression for the new
value and press the ENTER key.

As an alternative, you can type both registername and expression in the same
command.  You can use the equal sign (=) between reginstername and expression,
but a space has the same effect.

The register name can be any of the following names: AX, BX, CX, DX, CS, DS,
SS, ES, SP, BP, SI, DI, IP, or F (for flags).  If you have a 386-based
machine, and have turned the 386 option on, then the register name can be one
of the 32-bit register names shown in table 4.11.

To change a flag value, supply the register name F when you enter the Register
command.  The command displays the current value of each flag as a two-letter
name.

At the end of the list of values, the command displays a dash (-).  Enter new
values after the dash for the flags you wish to change, then press the ENTER
key.  You can enter flag values in any order.  Flags for which new values are
not entered remain unchanged.  If you do not want to change any flags, simply
press the ENTER key.

If you enter an illegal flag name, an error message will be displayed.  The
flags preceding the error are changed; flags at and following the error are
not changed.

The flag values are shown in Table 10.1.

Table 10.1 - Flag-Value Mnemonics
-------------------------------------
Flag Name		Set	Clear
-------------------------------------
Overflow		OV	NV
Direction		DN	UP
Interrupt		EI	DI
Sign			NG	PL
Zero			ZR	NZ
Auxiliary carry	AC	NA
Parity			PE	PO
Carry			CY	NC

<*> Examples

>R IP 256
>

The example above changes the IP register to the value 256 (0100 hexadecimal).

>R AX
AX 0E00
:_

The example above displays the current value of the AX register and prompts
for a new value (the underscore represents the CodeView cursor).  You can now
type any 16-bit value after the colon.

>R AX
AX 0E00
:256
>_

The example above changes the value of AX to 256 (in the current radix).

>R F UP EI PL

The example above shows the command-line method of changing flag values.

>R F
NV(OV) UP(DN) EI(DI) PL(NG) NZ(ZR) AC(NA) PE(PO) NC(CY) -OV DI ZR
>R F
OV(NV) UP(DN) DI(EI) PL(NG) ZR(NZ) AC(NA) PE(PO) NC(CY) -
>

With the prompting method of changing flags values (shown above), the first
mnemonic for each flag is the current value, and the second mnemonic (in
parentheses) is the alternate value.  You can enter one or more mnemonics at
the dash prompt.  In the example, the command is given a second time to show
the results of the first command.

.end of chapter.